const Service = require('egg').Service;
const svgCaptcha = require('svg-captcha');

class UserService extends Service {

    // 生成验证码
    async generateCaptcha() {
        const { ctx } = this;

        const captcha = svgCaptcha.create({
            size: 4, // 验证码长度
            ignoreChars: '0o1i', // 忽略容易混淆的字符
            noise: 2, // 干扰线条数
            color: true, // 彩色
            background: '#f0f2f5' // 背景色
        });

        // 将验证码文本存储到session中
        ctx.session.captcha = captcha.text.toLowerCase(); // 转为小写存储
        ctx.session.captchaId = Date.now().toString(); // 生成唯一ID

        // 设置session过期时间（5分钟）
        ctx.session.captchaExpire = Date.now() + 5 * 60 * 1000;

        return {
            captcha: captcha.data,
            captchaId: ctx.session.captchaId,
            expiresIn: 5 * 60 // 5分钟
        };
    }

    // 验证验证码
    async verifyCaptcha(captchaId, captchaText) {
        const { ctx } = this;

        // 检查session中是否存在验证码
        if (!ctx.session.captcha || !ctx.session.captchaId) {
            throw new Error('验证码已过期，请重新获取');
        }

        // 检查验证码ID是否匹配
        if (ctx.session.captchaId !== captchaId) {
            throw new Error('验证码ID不匹配');
        }

        // 检查验证码是否过期
        if (Date.now() > ctx.session.captchaExpire) {
            // 清除过期的验证码
            delete ctx.session.captcha;
            delete ctx.session.captchaId;
            delete ctx.session.captchaExpire;
            throw new Error('验证码已过期，请重新获取');
        }

        // 验证验证码文本（不区分大小写）
        if (ctx.session.captcha !== captchaText.toLowerCase()) {
            throw new Error('验证码错误');
        }

        // 验证成功后清除session中的验证码
        delete ctx.session.captcha;
        delete ctx.session.captchaId;
        delete ctx.session.captchaExpire;

        return true;
    }

    // 用户注册
    async register(userData) {
        const { ctx } = this;

        // 检查手机号是否已存在
        const existingPhone = await ctx.model.User.findOne({
            where: { phone: userData.phone }
        });
        if (existingPhone) {
            throw new Error('手机号已存在');
        }

        // 检查邮箱是否已存在
        const existingEmail = await ctx.model.User.findOne({
            where: { email: userData.email }
        });
        if (existingEmail) {
            throw new Error('邮箱已存在');
        }

        // 创建用户
        const user = await ctx.model.User.create({
            ...userData,
        });

        // 返回用户信息（排除密码）
        const { password, ...userInfo } = user.toJSON();
        return userInfo;
    }

    // 用户登录
    async login(loginData) {
        const { ctx } = this;

        const user = await ctx.model.User.findOne({
            where: {
                [ctx.app.Sequelize.Op.or]: [
                    { phone: loginData.username },
                    { email: loginData.username }
                ]
            }
        });

        if (!user) {
            throw new Error('用户不存在');
        }

        if (user.password !== loginData.password) {
            throw new Error('密码错误');
        }

        // 生成token
        const token = ctx.app.jwt.sign({
            user_id: user.user_id,
            username: loginData.username,
            type: 'user'  // 添加类型标识
        }, ctx.app.config.jwt.secret, {
            expiresIn: ctx.app.config.jwt.expiresIn
        });

        const { password, ...userInfo } = user.toJSON();
        return {
            user: userInfo,
            token
        };
    }

    // 获取用户列表（分页+搜索）
    async getUsers(query) {
        const { ctx } = this;
        const { page = 1, pageSize = 10, keyword, ...where } = query;

        // 构建查询条件
        const options = {
            where: {},
            limit: parseInt(pageSize),
            offset: (parseInt(page) - 1) * parseInt(pageSize),
            attributes: { exclude: ['password'] },
            order: [['created_at', 'DESC']]
        };

        // 添加关键词搜索条件
        if (keyword) {
            options.where[ctx.app.Sequelize.Op.or] = [
                { nickname: { [ctx.app.Sequelize.Op.like]: `%${keyword}%` } },
                { phone: { [ctx.app.Sequelize.Op.like]: `%${keyword}%` } },
                { email: { [ctx.app.Sequelize.Op.like]: `%${keyword}%` } },
            ];
        }

        // 添加其他精确查询条件
        const exactFields = ['phone', 'email', 'gender', 'user_id', 'verification_status'];
        exactFields.forEach(field => {
            if (where[field] !== undefined && where[field] !== '') {
                options.where[field] = where[field];
            }
        });

        // 添加昵称模糊搜索条件
        if (where.nickname) {
            options.where.nickname = {
                [ctx.app.Sequelize.Op.like]: `%${where.nickname}%`
            };
        }

        console.log('查询条件:', JSON.stringify(options.where, null, 2)); // 调试日志

        const { count, rows } = await ctx.model.User.findAndCountAll(options);

        return {
            list: rows,
            pagination: {
                page: parseInt(page),
                pageSize: parseInt(pageSize),
                total: count,
                totalPages: Math.ceil(count / pageSize)
            }
        };
    }

    // 根据ID获取用户详情
    async getUserById(userId) {
        const { ctx } = this;

        const user = await ctx.model.User.findByPk(userId, {
            attributes: { exclude: ['password', 'createdAt', 'updatedAt'] } // 排除密码字段
        });

        if (!user) {
            throw new Error('用户不存在');
        }

        return user;
    }

    // 更新用户信息
    async updateUser(userId, updateData) {
        const { ctx } = this;

        // 检查用户是否存在
        const user = await ctx.model.User.findByPk(userId);
        if (!user) {
            throw new Error('用户不存在');
        }

        // 如果更新手机号，检查是否重复
        if (updateData.phone && updateData.phone !== user.phone) {
            const existingPhone = await ctx.model.User.findOne({
                where: { phone: updateData.phone }
            });
            if (existingPhone) {
                throw new Error('手机号已存在');
            }
        }

        // 如果更新邮箱，检查是否重复
        if (updateData.email && updateData.email !== user.email) {
            const existingEmail = await ctx.model.User.findOne({
                where: { email: updateData.email }
            });
            if (existingEmail) {
                throw new Error('邮箱已存在');
            }
        }
        // 更新用户信息
        await user.update({
            ...updateData,
            updated_at: new Date()
        });

        // 返回更新后的用户信息（排除密码）
        const { createdAt, updatedAt, password, ...updatedUser } = user.toJSON();
        return updatedUser;
    }

    // 删除用户
    async deleteUser(userId) {
        const { ctx } = this;

        const user = await ctx.model.User.findByPk(userId);
        if (!user) {
            throw new Error('用户不存在');
        }

        await user.destroy();
        return true;
    }

    // 获取当前用户信息（用于token验证后）
    async getCurrentUser(userId) {
        const { ctx } = this;

        const user = await ctx.model.User.findByPk(userId, {
            attributes: { exclude: ['password'] }
        });

        if (!user) {
            throw new Error('用户不存在');
        }

        return user;
    }

    // 用户登出
    async logout() {
        return true;
    }
}

module.exports = UserService;